Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/maker/api.rs`:
- Around line 608-617: The recovery logs currently emit generic messages and
must include stable identifiers so concurrent recoveries are traceable: update
the log! and log::info! calls in src/maker/api.rs (the blocks that reference
txid, failed_swap_ip, maker_clone and the spawned recovery thread) to include
the peer IP (ip), the swap id (use the swap identifier variable in scope, e.g.,
swap_id or similar), and the contract txid; do the same for the other recovery
log sites you noted (around lines ~690-698 and ~747-866) so every
warning/info/error emitted from the recovery path concatenates or formats ip,
swap id and txid consistently to identify which swap/peer triggered the message.

---

Outside diff comments:
In `@src/maker/api.rs`:
- Around line 919-934: The current info log prints the entire WatchResponse
transaction (variable transaction) which can leak witness preimages; change the
logging in the loop over responses to avoid serializing witness data — instead
log safe identifiers such as transaction.txid (or a short outpoint summary built
from each input's previous_output.txid and vout) and/or the input count; keep
the rest of the logic that checks input.witness and calls
update_swapcoins_with_preimages(maker, incomings, &preimages, true) /
update_swapcoins_with_preimages(maker, outgoings, &preimages, false) unchanged,
and ensure no witness bytes are included in the new log.

In `@src/maker/handlers.rs`:
- Around line 56-63: The legacy handler logs drop the swap identifier making
messages ambiguous; update all log calls in src/maker/handlers.rs that handle
legacy swap messages (including the block for
TakerToMakerMessage::WaitingFundingConfirmation and the other ranges mentioned)
to include the swap id/message.id like the Taproot handler does—e.g., change
log::info!("Reserved ... UTXOs") / "Prepared outgoing funding txs" /
"Broadcasted funding txs" to include the id variable (or message.id) in the log
string, and propagate that id through the same code paths (where functions or
closures reference id, use the existing id.clone() or message.id) so every
legacy log line prints the swap id for unambiguous tracing.

In `@src/maker/server.rs`:
- Around line 333-379: In handle_client, capture the client's peer address once
at the start (call stream.peer_addr() and store it) and include that peer
identifier in all subsequent logs within this function (e.g., the "Connection
ended.", "<=== {}", "===> {}", and any error logs including the MakerError
branches and IO send errors); update log lines around read_message,
serde_cbor::from_slice, send_message, and the MakerError match so they prepend
or interpolate the stored peer address to provide per-connection context while
leaving existing control flow and error handling unchanged.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/maker/api.rs`:
- Around line 882-892: The code computes anchor_id inside the loop even though
it is loop-invariant; move the anchor_id computation out of the loop in the
Maker timelock recovery logic (same fix as recover_via_hashlock) by computing
let anchor_id = outgoing.first().map(|c|
c.contract_tx.compute_txid().to_string()).unwrap_or_default(); once before the
loop that references broadcasted and outgoing, then use that anchor_id in the
log::info! call(s) instead of recomputing it each iteration.
- Around line 822-832: Compute anchor_id once before the loop instead of
recomputing inside each iteration: move the call to incoming.first().map(|c|
c.contract_tx.compute_txid().to_string()).unwrap_or_default() out of the loop
and store it in a local variable named anchor_id, then use that anchor_id in the
existing log::info! call (the log invocation that references "[Contract: {}]
Maker hashlock recovery: ..."). This avoids repeatedly calling compute_txid() on
the same incoming.first() value during each loop iteration.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/maker/api.rs`:
- Around line 873-881: The method chain indentation for calling
broadcast_outgoing_contracts on maker.wallet.write() is inconsistent; reformat
the chain so it matches the project's style (each chained call on its own
indented line) for the expression that assigns infos (the call sequence
maker.wallet.write()?.broadcast_outgoing_contracts(outgoing.clone())?) and
ensure the following anchor_id assignment using
outgoing.first().map(...).unwrap_or_default() remains aligned with surrounding
code (e.g., mirror the layout used in recover_via_hashlock).

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/maker/handlers2.rs`:
- Around line 201-204: Update the two info logs that currently only print
swap_id so they include the protocol id (senders_contract.id) as well; e.g.
change the "Persisted incoming and outgoing swapcoins with swap_id={}" log to
include both senders_contract.id and swap_id in the message, and make the same
change for the other similar log at the nearby block (lines 207-210) so both
logs show "protocol_id={}" and "swap_id={}" together for easier
cross-referencing.

In `@src/maker/server.rs`:
- Around line 517-523: Accept currently throws away the peer address from
listener.accept(), which removes the per-session identifier and makes logs from
handle_client and its internal errors ambiguous; capture the peer address (e.g.,
let (mut stream, addr) = listener.accept() or rename to addr) and thread that
identifier into handle_client by updating its signature (e.g.,
handle_client(maker: &MakerType, stream: &mut TcpStream, peer: SocketAddr)) and
all internal logging sites so each log line (including "Connection ended", the
"<===", "===>", and error logs inside handle_client) includes the same peer
identifier for clear attribution across messages and sessions.

---

Outside diff comments:
In `@src/maker/handlers.rs`:
- Around line 56-63: The log message inside the match arm for
TakerToMakerMessage::WaitingFundingConfirmation should include the swap id so
you know which timer was reset; update the log::info! call in that arm to print
the id (e.g. log::info!("Taker is waiting for funding confirmation for swap {}.
Resetting timer.", id);) before modifying maker.ongoing_swap_state.lock()? and
returning Ok(None).

---

Duplicate comments:
In `@src/maker/api.rs`:
- Around line 755-799: The follow-up logs in recover_from_swap drop the
anchor_txid context; update the two log::info calls that currently print
"timelock expired..." and "all preimages known..." to include the anchor_txid
(the variable defined earlier) in their format string (e.g. prefix with
"[Contract: {}]" and pass anchor_txid) so those messages keep the same contract
context as the initial log; ensure you modify the log::info invocations before
calling recover_via_timelock and recover_via_hashlock respectively.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/maker/handlers2.rs`:
- Line 34: The debug log currently prints the entire TakerToMakerMessage (via
log::debug!("Handling message: {:?}", message)) which can leak secrets for the
PrivateKeyHandover variant; change the debug site to first convert the message
into a redacted form (e.g., match on TakerToMakerMessage and for
PrivateKeyHandover replace the sensitive payload with a fixed "[REDACTED]"
string or build a shallow redacted copy) and then log that redacted
representation instead; implement a small helper like
redacted_message_for_log(&TakerToMakerMessage) or a Display/Debug wrapper and
use it in the log::debug! call so only non-sensitive fields are printed while
PrivateKeyHandover payloads are omitted.
- Around line 64-71: After processing the taproot private key handover in
handle_privkey_handover, call Maker::sweep_after_successful_coinswap() and then
persist wallet state via maker.wallet().sync_and_save() (or the equivalent
sync_and_save method used in handlers.rs) before returning the
MakerToTakerMessage; specifically, after let response =
maker.process_private_key_handover(&privkey_handover, connection_state)? insert
a call to maker.sweep_after_successful_coinswap()? and then
maker.wallet().sync_and_save()? (or the corresponding methods on Maker) so the
taproot path mirrors the legacy handlers.rs behavior.

---

Duplicate comments:
In `@src/maker/server.rs`:
- Around line 349-380: Update the error log statements inside the handle_client
loop to include the peer attribution like the other logs: prefix each
log::error! at the locations that currently log without "[Peer: {}]" (the IO
send error path around send_message, the MakerError::SpecialBehaviour branch,
and the generic Err branch after handle_message) to use the same format string
with "[Peer: {}]" and pass addr as the first formatter argument so all errors
consistently show the peer (use the same logging style as the existing
log::info!("[Peer: {}] ...", addr, ...)).